import { ref } from 'vue'

/**
 * 分页表格组合式API - 支持多种响应结构
 * @param {Function} fetchData - 数据获取函数，需返回Promise
 * @returns {Object} 包含状态和方法的管理对象
 */
export default function useTable(fetchData) {
  // 响应式状态管理
  const state = ref({
    currentPage: 1,       // 当前页码
    pageSize: 20,         // 每页显示数量
    totalItems: 0,        // 总记录数
    searchParams: {},     // 搜索参数对象（支持多个字段）
    searchKeyword: '',    // 搜索关键字
    sortField: null,      // 排序字段
    sortOrder: null,      // 排序方向 (asc/desc)
    pageData: [],         // 当前页数据
    loading: false,       // 加载状态
    error: null           // 错误信息
  });

  /**
   * 构建标准化请求参数
   * @returns {Object} 请求参数对象
   */
  const buildRequestParams = () => {
    // 基础分页参数
    const params = {
      page: state.value.currentPage,
      size: state.value.pageSize,
    };

    // 添加搜索参数（过滤掉空字符串）
    Object.entries(state.value.searchParams).forEach(([key, value]) => {
      // 特殊处理数组参数 - 保持原始数组格式
      if (Array.isArray(value) && value.length > 0) {
        params[key] = value
      } else if (value !== '' && value !== null && value !== undefined) {
        params[key] = value;
      }
    });
    
    // 添加搜索关键字参数
    if (state.value.searchKeyword) {
      // 根据实际后端接口参数名设置
      params.search = state.value.searchKeyword;
    }
    
    // 添加排序参数（使用后端需要的字段名）
    if (state.value.sortField) {
      params.sortField = state.value.sortField;
      // 只有当排序方向存在时才添加
      if (state.value.sortOrder) {
        params.sortOrder = state.value.sortOrder;
      }
    }
    
    console.debug('[useTable] 请求参数:', params);
    return params;
  };

  /**
   * 数据验证与标准化 - 兼容多种响应结构
   * @param {Object} data - API响应数据
   * @returns {Object} 标准化后的数据结构
   */
  const normalizeResponse = (data) => {
    // 处理标准分页结构 (records + total)
    if (data && Array.isArray(data.records) && typeof data.total === 'number') {
      return {
        content: data.records,
        total: data.total
      }
    }
    
    // 处理另一种分页结构 (list + total)
    if (data && Array.isArray(data.list) && typeof data.total === 'number') {
      return {
        content: data.list,
        total: data.total
      }
    }
    
    // 处理 content/total 结构
    if (data && Array.isArray(data.content) && typeof data.total === 'number') {
      return {
        content: data.content,
        total: data.total
      }
    }
    
    // 处理直接返回数组的情况
    if (Array.isArray(data)) {
      return { content: data, total: data.length }
    }
    
    // 处理包含分页信息的其他结构
    if (data && Array.isArray(data.data) && typeof data.total === 'number') {
      return {
        content: data.data,
        total: data.total
      }
    }
    
    console.error('[useTable] 无法解析的响应结构:', data);
    return { content: [], total: 0 }
  };

  /**
   * 加载表格数据
   * @param {Object} [externalParams] - 外部传入的额外参数
   */
  const loadData = async (externalParams = {}) => {
    console.log('[useTable] loadData 被调用，外部参数:', externalParams)
    console.log('[useTable] 当前状态:', {
      currentPage: state.value.currentPage,
      pageSize: state.value.pageSize,
      totalItems: state.value.totalItems,
      searchParams: state.value.searchParams
    })
    
    state.value.loading = true;
    state.value.error = null;

    try {
      // 合并内部状态和外部参数
      const baseParams = buildRequestParams();
      const params = { ...baseParams, ...externalParams };

      console.log('[useTable] API请求参数:', JSON.stringify(params, null, 2));
      
      // 调用 API 获取响应
      const response = await fetchData(params);
      
      // 提取响应数据部分（兼容不同API的响应结构）
      const responseData = response.data || response;
      console.log('[useTable] 原始响应数据:', responseData)
      
      // 标准化响应数据
      const normalizedData = normalizeResponse(responseData);
      console.log('[useTable] 标准化后的数据:', normalizedData)
      
      state.value.pageData = normalizedData.content;
      state.value.totalItems = normalizedData.total;
      console.log('[useTable] 更新后的状态:', {
        pageDataLength: state.value.pageData.length,
        totalItems: state.value.totalItems
      })

      // 分页校正逻辑
      if (state.value.pageData.length === 0 && state.value.currentPage > 1) {
        state.value.currentPage = 1;
        await loadData(externalParams); // 重新加载时保持外部参数
      }
    } catch (error) {
      console.error('[useTable] 数据加载失败:', error);
      state.value.error = error;
      state.value.pageData = [];
      state.value.totalItems = 0;
    } finally {
      state.value.loading = false;
    }
  }

  /**
   * 处理排序变化
   * @param {Object} sort - 排序对象
   * @param {string} sort.field - 排序字段
   * @param {string} sort.order - 排序顺序 (asc/desc)
   */
  const handleSortChange = ({ field, order }) => {
    // 清除排序状态
    if (!field) {
      state.value.sortField = null;
      state.value.sortOrder = null;
      console.log('[useTable] 清除排序状态');
      state.value.currentPage = 1;
      loadData();
      return;
    }

    // 更新排序状态
    state.value.sortField = field;
    state.value.sortOrder = order;
    
    console.log(`[useTable] 更新排序: ${field} ${order}`);
    
    // 重置到第一页并加载数据
    state.value.currentPage = 1;
    loadData();
  }

  /**
   * 更新搜索参数并触发加载
   * @param {Object} params - 新的搜索参数
   */
  const updateSearchParams = (params) => {
    // 过滤掉空值
    const filteredParams = {};
    Object.entries(params).forEach(([key, value]) => {
      if (value !== '' && value !== null && value !== undefined) {
        filteredParams[key] = value;
      }
    });
    
    state.value.searchParams = { ...filteredParams };
    state.value.currentPage = 1;
    loadData();
  }

  /**
   * 重置搜索参数
   * @param {Object} defaultParams - 默认参数
   */
  const resetSearchParams = (defaultParams = {}) => {
    state.value.searchParams = { ...defaultParams };
    state.value.currentPage = 1;
    loadData();
  }
  
  /**
   * 设置搜索参数但不触发加载
   * @param {Object} params - 新的搜索参数
   */
  const setSearchParams = (params) => {
    state.value.searchParams = { ...params };
  }
  
  /**
   * 设置搜索关键字但不触发加载
   * @param {string} keyword - 新的搜索关键字
   */
  const setSearchKeyword = (keyword) => {
    state.value.searchKeyword = keyword;
  }

  /**
   * 处理每页显示数量变化
   * @param {number} size - 新的每页显示数量
   */
  const handleSizeChange = (size) => {
    state.value.pageSize = size;
    state.value.currentPage = 1;
    loadData();
  }

  /**
   * 处理当前页码变化
   * @param {number} page - 新的页码
   */
  const handleCurrentChange = (page) => {
    state.value.currentPage = page;
    loadData();
  }

  return {
    state,
    loadData,
    handleSortChange,
    handleSizeChange,
    handleCurrentChange,
    updateSearchParams,
    resetSearchParams,
    setSearchParams,
    setSearchKeyword
  }
} 